package com.sugar.reflection;

import java.lang.reflect.Constructor;

/**
 * @author felix
 * @date 2025/2/10 10:03
 */
public class ReflectDemo2 {
    static void demo1() throws Exception {
        //测试类中的代码：
        //需求1：
        //获取空参，并创建对象
        //1.获取整体的字节码文件对象
        Class clazz = Class.forName("com.sugar.reflection.Student");
        //2.获取空参的构造方法
        Constructor con = clazz.getConstructor();
        //3.利用空参构造方法创建对象
        Student stu = (Student) con.newInstance();
        System.out.println(con);
        System.out.println(stu);


        System.out.println("=============================================");
    }

    static void demo2() throws Exception{
        //测试类中的代码：
        //需求2：
        //获取带参构造，并创建对象
        //1.获取整体的字节码文件对象
        Class clazz1 = Class.forName("com.sugar.reflection.Student");
        //2.获取有参构造方法
        Constructor con1 = clazz1.getDeclaredConstructor(String.class, int.class);
        //3.临时修改构造方法的访问权限（暴力反射）
        con1.setAccessible(true);
        //4.直接创建对象
        Student stu1 = (Student) con1.newInstance("zhangsan", 23);
        System.out.println(con1);
        System.out.println(stu1);
    }

    static void demo3() throws Exception{
        /**
         * 获取字节码文件对象三种方式
         */
        Class<?> clazz = Class.forName("com.sugar.reflection.Person");

        Person person = new Person();
        Class<?> clazz2 = person.getClass();

        Class<?> clazz3 = Person.class;
        System.out.println(clazz==clazz2);

        System.out.println(clazz2==clazz3);
    }

    /**
     * 获取构造方法
     * @throws Exception
     */
    static void demo4() throws Exception{
        //1.获得整体（class字节码文件对象）
        Class clazz = Class.forName("com.sugar.reflection.Student");


        //2.获取构造方法对象
        //获取所有构造方法（public）
        Constructor[] constructors1 = clazz.getConstructors();
        for (Constructor constructor : constructors1) {
            System.out.println(constructor);
        }

        System.out.println("=======================");

        //获取所有构造（带私有的）
        Constructor[] constructors2 = clazz.getDeclaredConstructors();

        for (Constructor constructor : constructors2) {
            System.out.println(constructor);
        }
        System.out.println("=======================");

        //获取指定的空参构造
        Constructor con1 = clazz.getConstructor();
        System.out.println(con1);

        Constructor con2 = clazz.getConstructor(String.class,String.class,int.class);
        System.out.println(con2);

        System.out.println("=======================");
        //获取指定的构造(所有构造都可以获取到，包括public包括private)
        Constructor con3 = clazz.getDeclaredConstructor();
        System.out.println(con3);
        //了解 System.out.println(con3 == con1);
        //每一次获取构造方法对象的时候，都会新new一个。

        Constructor con4 = clazz.getDeclaredConstructor(String.class);
        System.out.println(con4);
    }

    public static void main(String[] args) throws Exception {
//        demo1();
//        demo2();
//        demo3();
        demo4();
    }
}
